home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / imputil.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  15.2 KB  |  447 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import imp
  5. import sys
  6. import __builtin__
  7. import struct
  8. import marshal
  9. __all__ = [
  10.     'ImportManager',
  11.     'Importer',
  12.     'BuiltinImporter']
  13. _StringType = type('')
  14. _ModuleType = type(sys)
  15.  
  16. class ImportManager:
  17.     
  18.     def install(self, namespace = vars(__builtin__)):
  19.         if isinstance(namespace, _ModuleType):
  20.             namespace = vars(namespace)
  21.         
  22.         self.previous_importer = namespace['__import__']
  23.         self.namespace = namespace
  24.         namespace['__import__'] = self._import_hook
  25.  
  26.     
  27.     def uninstall(self):
  28.         self.namespace['__import__'] = self.previous_importer
  29.  
  30.     
  31.     def add_suffix(self, suffix, importFunc):
  32.         self.fs_imp.add_suffix(suffix, importFunc)
  33.  
  34.     clsFilesystemImporter = None
  35.     
  36.     def __init__(self, fs_imp = None):
  37.         if not _os_stat:
  38.             _os_bootstrap()
  39.         
  40.         if fs_imp is None:
  41.             if not self.clsFilesystemImporter:
  42.                 pass
  43.             cls = _FilesystemImporter
  44.             fs_imp = cls()
  45.         
  46.         self.fs_imp = fs_imp
  47.         for desc in imp.get_suffixes():
  48.             if desc[2] == imp.C_EXTENSION:
  49.                 self.add_suffix(desc[0], DynLoadSuffixImporter(desc).import_file)
  50.                 continue
  51.         
  52.         self.add_suffix('.py', py_suffix_importer)
  53.  
  54.     
  55.     def _import_hook(self, fqname, globals = None, locals = None, fromlist = None):
  56.         parts = fqname.split('.')
  57.         parent = self._determine_import_context(globals)
  58.         if parent:
  59.             module = parent.__importer__._do_import(parent, parts, fromlist)
  60.             if module:
  61.                 return module
  62.             
  63.         
  64.         
  65.         try:
  66.             top_module = sys.modules[parts[0]]
  67.         except KeyError:
  68.             top_module = self._import_top_module(parts[0])
  69.             if not top_module:
  70.                 raise ImportError, 'No module named ' + fqname
  71.             
  72.         except:
  73.             not top_module
  74.  
  75.         if len(parts) == 1:
  76.             if not fromlist:
  77.                 return top_module
  78.             
  79.             if not top_module.__dict__.get('__ispkg__'):
  80.                 return top_module
  81.             
  82.         
  83.         importer = top_module.__dict__.get('__importer__')
  84.         if importer:
  85.             return importer._finish_import(top_module, parts[1:], fromlist)
  86.         
  87.         if len(parts) == 2 and hasattr(top_module, parts[1]):
  88.             return top_module
  89.         
  90.         raise ImportError, 'No module named ' + fqname
  91.  
  92.     
  93.     def _determine_import_context(self, globals):
  94.         if not globals or not globals.get('__importer__'):
  95.             return None
  96.         
  97.         parent_fqname = globals['__name__']
  98.         if globals['__ispkg__']:
  99.             parent = sys.modules[parent_fqname]
  100.             return parent
  101.         
  102.         i = parent_fqname.rfind('.')
  103.         if i == -1:
  104.             return None
  105.         
  106.         parent_fqname = parent_fqname[:i]
  107.         parent = sys.modules[parent_fqname]
  108.         return parent
  109.  
  110.     
  111.     def _import_top_module(self, name):
  112.         for item in sys.path:
  113.             if isinstance(item, _StringType):
  114.                 module = self.fs_imp.import_from_dir(item, name)
  115.             else:
  116.                 module = item.import_top(name)
  117.             if module:
  118.                 return module
  119.                 continue
  120.         
  121.         return None
  122.  
  123.     
  124.     def _reload_hook(self, module):
  125.         importer = module.__dict__.get('__importer__')
  126.         if not importer:
  127.             pass
  128.         
  129.         raise SystemError, 'reload not yet implemented'
  130.  
  131.  
  132.  
  133. class Importer:
  134.     
  135.     def import_top(self, name):
  136.         return self._import_one(None, name, name)
  137.  
  138.     
  139.     def _finish_import(self, top, parts, fromlist):
  140.         bottom = self._load_tail(top, parts)
  141.         if not fromlist:
  142.             return top
  143.         
  144.         if bottom.__ispkg__:
  145.             self._import_fromlist(bottom, fromlist)
  146.         
  147.         return bottom
  148.  
  149.     
  150.     def _import_one(self, parent, modname, fqname):
  151.         
  152.         try:
  153.             return sys.modules[fqname]
  154.         except KeyError:
  155.             pass
  156.  
  157.         result = self.get_code(parent, modname, fqname)
  158.         if result is None:
  159.             return None
  160.         
  161.         module = self._process_result(result, fqname)
  162.         if parent:
  163.             setattr(parent, modname, module)
  164.         
  165.         return module
  166.  
  167.     
  168.     def _process_result(self, .2, fqname):
  169.         (ispkg, code, values) = .2
  170.         is_module = isinstance(code, _ModuleType)
  171.         if is_module:
  172.             module = code
  173.         else:
  174.             module = imp.new_module(fqname)
  175.         module.__importer__ = self
  176.         module.__ispkg__ = ispkg
  177.         module.__dict__.update(values)
  178.         sys.modules[fqname] = module
  179.         if not is_module:
  180.             exec code in module.__dict__
  181.         
  182.         module = sys.modules[fqname]
  183.         module.__name__ = fqname
  184.         return module
  185.  
  186.     
  187.     def _load_tail(self, m, parts):
  188.         for part in parts:
  189.             fqname = '%s.%s' % (m.__name__, part)
  190.             m = self._import_one(m, part, fqname)
  191.             if not m:
  192.                 raise ImportError, 'No module named ' + fqname
  193.                 continue
  194.         
  195.         return m
  196.  
  197.     
  198.     def _import_fromlist(self, package, fromlist):
  199.         if '*' in fromlist:
  200.             fromlist = list(fromlist) + list(package.__dict__.get('__all__', []))
  201.         
  202.         for sub in fromlist:
  203.             if sub != '*' and not hasattr(package, sub):
  204.                 subname = '%s.%s' % (package.__name__, sub)
  205.                 submod = self._import_one(package, sub, subname)
  206.                 if not submod:
  207.                     raise ImportError, 'cannot import name ' + subname
  208.                 
  209.             not submod
  210.         
  211.  
  212.     
  213.     def _do_import(self, parent, parts, fromlist):
  214.         top_name = parts[0]
  215.         top_fqname = parent.__name__ + '.' + top_name
  216.         top_module = self._import_one(parent, top_name, top_fqname)
  217.         if not top_module:
  218.             return None
  219.         
  220.         return self._finish_import(top_module, parts[1:], fromlist)
  221.  
  222.     
  223.     def get_code(self, parent, modname, fqname):
  224.         raise RuntimeError, 'get_code not implemented'
  225.  
  226.  
  227. if not __debug__ and 'c':
  228.     pass
  229. _suffix_char = 'o'
  230. _suffix = '.py' + _suffix_char
  231.  
  232. def _compile(pathname, timestamp):
  233.     codestring = open(pathname, 'rU').read()
  234.     if codestring and codestring[-1] != '\n':
  235.         codestring = codestring + '\n'
  236.     
  237.     code = __builtin__.compile(codestring, pathname, 'exec')
  238.     
  239.     try:
  240.         f = open(pathname + _suffix_char, 'wb')
  241.     except IOError:
  242.         pass
  243.  
  244.     f.write('\x00\x00\x00\x00')
  245.     f.write(struct.pack('<I', timestamp))
  246.     marshal.dump(code, f)
  247.     f.flush()
  248.     f.seek(0, 0)
  249.     f.write(imp.get_magic())
  250.     f.close()
  251.     return code
  252.  
  253. _os_stat = _os_path_join = None
  254.  
  255. def _os_bootstrap():
  256.     global _os_stat, _os_path_join
  257.     names = sys.builtin_module_names
  258.     join = None
  259.     if 'posix' in names:
  260.         sep = '/'
  261.         stat = stat
  262.         import posix
  263.     elif 'nt' in names:
  264.         sep = '\\'
  265.         stat = stat
  266.         import nt
  267.     elif 'dos' in names:
  268.         sep = '\\'
  269.         stat = stat
  270.         import dos
  271.     elif 'os2' in names:
  272.         sep = '\\'
  273.         stat = stat
  274.         import os2
  275.     elif 'mac' in names:
  276.         stat = stat
  277.         import mac
  278.         
  279.         def join(a, b):
  280.             if a == '':
  281.                 return b
  282.             
  283.             if ':' not in a:
  284.                 a = ':' + a
  285.             
  286.             if a[-1:] != ':':
  287.                 a = a + ':'
  288.             
  289.             return a + b
  290.  
  291.     else:
  292.         raise ImportError, 'no os specific module found'
  293.     if join is None:
  294.         
  295.         def join(a, b, sep = sep):
  296.             if a == '':
  297.                 return b
  298.             
  299.             lastchar = a[-1:]
  300.             if lastchar == '/' or lastchar == sep:
  301.                 return a + b
  302.             
  303.             return a + sep + b
  304.  
  305.     
  306.     _os_stat = stat
  307.     _os_path_join = join
  308.  
  309.  
  310. def _os_path_isdir(pathname):
  311.     
  312.     try:
  313.         s = _os_stat(pathname)
  314.     except OSError:
  315.         return None
  316.  
  317.     return s.st_mode & 61440 == 16384
  318.  
  319.  
  320. def _timestamp(pathname):
  321.     
  322.     try:
  323.         s = _os_stat(pathname)
  324.     except OSError:
  325.         return None
  326.  
  327.     return long(s.st_mtime)
  328.  
  329.  
  330. class BuiltinImporter(Importer):
  331.     
  332.     def get_code(self, parent, modname, fqname):
  333.         if parent:
  334.             return None
  335.         
  336.         if imp.is_builtin(modname):
  337.             type = imp.C_BUILTIN
  338.         elif imp.is_frozen(modname):
  339.             type = imp.PY_FROZEN
  340.         else:
  341.             return None
  342.         module = imp.load_module(modname, None, modname, ('', '', type))
  343.         return (0, module, { })
  344.  
  345.  
  346.  
  347. class _FilesystemImporter(Importer):
  348.     
  349.     def __init__(self):
  350.         self.suffixes = []
  351.  
  352.     
  353.     def add_suffix(self, suffix, importFunc):
  354.         self.suffixes.append((suffix, importFunc))
  355.  
  356.     
  357.     def import_from_dir(self, dir, fqname):
  358.         result = self._import_pathname(_os_path_join(dir, fqname), fqname)
  359.         if result:
  360.             return self._process_result(result, fqname)
  361.         
  362.         return None
  363.  
  364.     
  365.     def get_code(self, parent, modname, fqname):
  366.         return self._import_pathname(_os_path_join(parent.__pkgdir__, modname), fqname)
  367.  
  368.     
  369.     def _import_pathname(self, pathname, fqname):
  370.         if _os_path_isdir(pathname):
  371.             result = self._import_pathname(_os_path_join(pathname, '__init__'), fqname)
  372.             if result:
  373.                 values = result[2]
  374.                 values['__pkgdir__'] = pathname
  375.                 values['__path__'] = [
  376.                     pathname]
  377.                 return (1, result[1], values)
  378.             
  379.             return None
  380.         
  381.         for suffix, importFunc in self.suffixes:
  382.             filename = pathname + suffix
  383.             
  384.             try:
  385.                 finfo = _os_stat(filename)
  386.             except OSError:
  387.                 continue
  388.  
  389.             return importFunc(filename, finfo, fqname)
  390.         
  391.         return None
  392.  
  393.  
  394.  
  395. def py_suffix_importer(filename, finfo, fqname):
  396.     file = filename[:-3] + _suffix
  397.     t_py = long(finfo[8])
  398.     t_pyc = _timestamp(file)
  399.     code = None
  400.     if t_pyc is not None and t_pyc >= t_py:
  401.         f = open(file, 'rb')
  402.         if f.read(4) == imp.get_magic():
  403.             t = struct.unpack('<I', f.read(4))[0]
  404.             if t == t_py:
  405.                 code = marshal.load(f)
  406.             
  407.         
  408.         f.close()
  409.     
  410.     if code is None:
  411.         file = filename
  412.         code = _compile(file, t_py)
  413.     
  414.     return (0, code, {
  415.         '__file__': file })
  416.  
  417.  
  418. class DynLoadSuffixImporter:
  419.     
  420.     def __init__(self, desc):
  421.         self.desc = desc
  422.  
  423.     
  424.     def import_file(self, filename, finfo, fqname):
  425.         fp = open(filename, self.desc[1])
  426.         module = imp.load_module(fqname, fp, filename, self.desc)
  427.         module.__file__ = filename
  428.         return (0, module, { })
  429.  
  430.  
  431.  
  432. def _print_importers():
  433.     items = sys.modules.items()
  434.     items.sort()
  435.     for name, module in items:
  436.         if module:
  437.             print name, module.__dict__.get('__importer__', '-- no importer')
  438.             continue
  439.         print name, '-- non-existent module'
  440.     
  441.  
  442.  
  443. def _test_revamp():
  444.     ImportManager().install()
  445.     sys.path.insert(0, BuiltinImporter())
  446.  
  447.